package org.example.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.example.common.result.PageResult;
import org.example.entity.User;
import org.example.mapper.UserMapper;
import org.example.mapper.UserRoleCompanyRelationMapper;
import org.example.mapper.UserRolePlatformRelationMapper;
import org.example.service.SmsService;
import org.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * 用户服务实现类
 */
@Service
@Slf4j
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserMapper userMapper;
    
    @Autowired
    private UserRolePlatformRelationMapper userRolePlatformRelationMapper;
    
    @Autowired
    private UserRoleCompanyRelationMapper userRoleCompanyRelationMapper;
    
    @Autowired
    private SmsService smsService;


    
    @Override
    public User getByPhone(String phone) {
        // 注意：此方法已废弃，建议使用 getByPhoneAndUserType 方法
        // 因为现在支持不同端手机号重复
        log.warn("使用已废弃的 getByPhone 方法，建议使用 getByPhoneAndUserType");
        return getByPhoneAndUserType(phone, null);
    }
    
    /**
     * 根据手机号和用户类型查询用户（推荐使用）
     * @param phone 手机号
     * @param userType 用户类型（平台端/企业端/用户端），如果为null则返回第一个匹配的用户
     * @return 用户对象
     */
    @Override
    public User getByPhoneAndUserType(String phone, String userType) {
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<User> queryWrapper = 
            new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<User>()
                .eq("phone", phone);
        
        if (userType != null) {
            queryWrapper.eq("user_type", userType);
        }
        
        List<User> users = userMapper.selectList(queryWrapper);
        
        if (users.isEmpty()) {
            return null;
        }
        
        // 如果指定了用户类型，应该只有一个结果
        if (userType != null && users.size() > 1) {
            log.warn("发现重复手机号用户: {}, 用户类型: {}, 数量: {}", phone, userType, users.size());
        }
        
        return users.get(0);
    }
    
    @Override
    public User getById(Long id) {
        return userMapper.selectById(id);
    }
    
    // ========== 平台端用户管理方法实现 ==========
    
    @Override
    public PageResult<User> getPlatformUserList(Integer page, Integer size, String username, String phone) {
        // 构建查询条件
        com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<User> queryWrapper = 
            new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<User>()
                .eq("user_type", "平台端");  // 只查询平台端用户
        
        // 添加搜索条件
        if (username != null && !username.trim().isEmpty()) {
            queryWrapper.like("username", username);
        }
        if (phone != null && !phone.trim().isEmpty()) {
            queryWrapper.like("phone", phone);
        }
        
        // 分页查询
        com.baomidou.mybatisplus.extension.plugins.pagination.Page<User> pageParam = 
            new com.baomidou.mybatisplus.extension.plugins.pagination.Page<>(page, size);
        
        com.baomidou.mybatisplus.extension.plugins.pagination.Page<User> result = 
            userMapper.selectPage(pageParam, queryWrapper);
        
        // 修复类型转换问题：将Integer转换为Long
        return new PageResult<>(
            Long.valueOf(page), 
            Long.valueOf(size), 
            result.getTotal(), 
            result.getRecords()
        );
    }
    
    @Override
    public User getPlatformUserById(Long userId) {
        User user = userMapper.selectById(userId);
        if (user != null && "平台端".equals(user.getUserType())) {
            return user;
        }
        return null;
    }
    
    @Override
    @Transactional
    public User createPlatformUser(User user) {
        // 设置平台端用户属性
        user.setUserType("平台端");
        if (user.getIsPlatformAdmin() == null) {
            user.setIsPlatformAdmin(0);
        }
        // 平台端不关联企业，不再持久化 currentCompanyId
        
        // 插入用户
        userMapper.insert(user);
        // 如需设置角色，请通过 assignPlatformRoles 或控制器层处理关联表
        return user;
    }
    
    @Override
    @Transactional
    public User updatePlatformUser(User user) {
        // 确保是平台端用户
        User existingUser = getPlatformUserById(user.getId());
        if (existingUser == null) {
            throw new RuntimeException("用户不存在或不是平台端用户");
        }
        
        // 更新用户信息
        userMapper.updateById(user);
        
        // 角色关联改由控制器或专门方法处理
        
        return getPlatformUserById(user.getId());
    }
    
    @Override
    @Transactional
    public void deletePlatformUser(Long userId) {
        User user = getPlatformUserById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在或不是平台端用户");
        }
        
        // 删除用户
        userMapper.deleteById(userId);
        
        // 删除用户角色关联关系
        userRolePlatformRelationMapper.deleteByUserId(userId);
    }
    
    @Override
    @Transactional
    public void assignPlatformRoles(Long userId, List<Long> roleIds) {
        User user = getPlatformUserById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在或不是平台端用户");
        }
        
        // 实现角色分配逻辑
        // 1. 删除现有角色关联
        // 2. 插入新的角色关联
        // 3. 同步平台关联表即可
        
        if (roleIds == null || roleIds.isEmpty()) {
            throw new RuntimeException("角色ID列表不能为空");
        }
        
        // 实现用户角色关联表的操作
        // 1. 删除现有角色关联
        userRolePlatformRelationMapper.deleteByUserId(userId);
        // 2. 插入新的角色关联
        userRolePlatformRelationMapper.batchInsert(userId, roleIds);
    }
    
    @Override
    @Transactional
    public void updatePlatformUserStatus(Long userId, Integer status) {
        User user = getPlatformUserById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在或不是平台端用户");
        }
        
        // 验证状态值
        if (status == null || (status != 0 && status != 1)) {
            throw new IllegalArgumentException("状态参数无效，请使用0(禁用)或1(启用)");
        }
        
        // 更新用户状态
        User updateUser = new User();
        updateUser.setId(userId);
        updateUser.setStatus(status);
        userMapper.updateById(updateUser);
    }
    
    @Override
    @Transactional
    public void resetPlatformUserPassword(Long userId) {
        User user = getPlatformUserById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在或不是平台端用户");
        }
        
        // 重置密码为默认密码
        User updateUser = new User();
        updateUser.setId(userId);
        updateUser.setPasswordHash("123456");  // TODO: 使用加密后的默认密码
        userMapper.updateById(updateUser);
    }

    @Override
    @Transactional
    public void changePlatformUserPhone(Long userId, String oldPhone, String oldCode, String newPhone, String newCode) {
        User user = getPlatformUserById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在或不是平台端用户");
        }
        if (user.getPhone() == null || !user.getPhone().equals(oldPhone)) {
            throw new IllegalArgumentException("旧手机号不匹配");
        }
        if (oldPhone.equals(newPhone)) {
            throw new IllegalArgumentException("新旧手机号不能相同");
        }
        // 校验验证码（平台端）
        if (!smsService.verifyCode(oldPhone, oldCode, "平台端")) {
            throw new IllegalArgumentException("旧手机号验证码错误或过期");
        }
        if (!smsService.verifyCode(newPhone, newCode, "平台端")) {
            throw new IllegalArgumentException("新手机号验证码错误或过期");
        }
        // 新手机号唯一性校验
        User exists = getByPhone(newPhone);
        if (exists != null && !exists.getId().equals(userId)) {
            throw new IllegalArgumentException("新手机号已被占用");
        }
        // 更新手机号（如用户名等有依赖，可一并更新）
        User update = new User();
        update.setId(userId);
        update.setPhone(newPhone);
        userMapper.updateById(update);
    }

    @Override
    public boolean hasAccessToCompany(Long userId, Long companyId) {
        if (userId == null || companyId == null) {
            return false;
        }
        
        try {
            // 方法1：通过用户角色公司关联表验证，同时检查is_active状态
            // 查询用户在该租户下是否有活跃的角色关联
            List<Long> roleIds = userRoleCompanyRelationMapper.getActiveRoleIdsByUserIdAndCompanyId(userId, companyId);
            if (roleIds != null && !roleIds.isEmpty()) {
                return true;
            }
            
            // 方法2：通过用户表的currentCompanyId验证（备用方案）
            User user = getById(userId);
            if (user != null && companyId.equals(user.getCurrentCompanyId())) {
                return true;
            }
            
            return false;
        } catch (Exception e) {
            log.error("验证用户租户权限失败: userId={}, companyId={}", userId, companyId, e);
            return false;
        }
    }
    
    @Override
    public int countUsersByRoleId(Long roleId, Long companyId) {
        try {
            // 统计指定角色下的用户数量（企业端）
            return userRoleCompanyRelationMapper.countUsersByRoleIdAndCompanyId(roleId, companyId);
        } catch (Exception e) {
            log.error("统计角色用户数量失败: roleId={}, companyId={}", roleId, companyId, e);
            return 0;
        }
    }
}
